diff --git a/actions/threads.tsx b/actions/threads.tsx
index a642e7a7..56cd9973 100644
--- a/actions/threads.tsx
+++ b/actions/threads.tsx
@@ -1,6 +1,6 @@
 "use server"
 
-import {THREADS_DIR} from "@/config/env";
+import {THREADS_DIR, WORKSPACE_DIR} from "@/config/env";
 import {gpt} from "@/config/env";
 import fs from "fs/promises";
 import path from 'path';
@@ -20,6 +20,7 @@ export type ThreadMeta = {
     updated: Date;
     id: string;
     script: string;
+    workspace: string;
 }
 
 export async function init() {
@@ -67,7 +68,11 @@ export async function getThreads() {
 
 export async function getThread(id: string) {
     const threads = await getThreads();
-    return threads.find(thread => thread.meta.id === id);
+    const thread = threads.find(thread => thread.meta.id === id);
+    if (!thread) return null;
+    // falsy check for workspace to account for old threads that don't have a workspace
+    if (thread.meta.workspace == undefined) thread.meta.workspace = WORKSPACE_DIR();
+    return thread;
 }
 
 async function newThreadName(): Promise<string> {
@@ -96,8 +101,9 @@ export async function createThread(script: string, firstMessage?: string): Promi
         description: '',
         created: new Date(),
         updated: new Date(),
+        workspace: WORKSPACE_DIR(),
         id,
-        script
+        script,
     }
     const threadState = '';
 
@@ -129,3 +135,12 @@ export async function renameThread(id: string, name: string) {
     threadMeta.name = name;
     await fs.writeFile(path.join(threadPath, META_FILE), JSON.stringify(threadMeta));
 }
+
+export async function updateThreadWorkspace(id: string, workspace: string) {
+    const threadsDir = THREADS_DIR();
+    const threadPath = path.join(threadsDir,id);
+    const meta = await fs.readFile(path.join(threadPath, META_FILE), "utf-8");
+    const threadMeta = JSON.parse(meta) as ThreadMeta;
+    threadMeta.workspace = workspace;
+    await fs.writeFile(path.join(threadPath, META_FILE), JSON.stringify(threadMeta));
+}
diff --git a/actions/upload.tsx b/actions/upload.tsx
index b739ae99..ce583188 100644
--- a/actions/upload.tsx
+++ b/actions/upload.tsx
@@ -2,19 +2,16 @@
 
 import fs from "node:fs/promises";
 import path from "node:path";
-import {revalidatePath} from "next/cache";
-import {WORKSPACE_DIR} from '@/config/env';
-import {Dirent} from 'fs';
-
-export async function uploadFile(formData: FormData) {
-    const workspaceDir = WORKSPACE_DIR()
-    await fs.mkdir(workspaceDir, {recursive: true})
+import { revalidatePath } from "next/cache";
+import { Dirent } from 'fs';
 
+export async function uploadFile(workspace: string, formData: FormData) {
     const file = formData.get("file") as File;
+    await fs.mkdir(workspace, { recursive: true })
+
     const arrayBuffer = await file.arrayBuffer();
     const buffer = new Uint8Array(arrayBuffer);
-    await fs.writeFile(path.join(workspaceDir, file.name), buffer);
-
+    await fs.writeFile(path.join(workspace,file.name), buffer);
     revalidatePath("/");
 }
 
@@ -27,10 +24,10 @@ export async function deleteFile(path: string) {
     }
 }
 
-export async function lsWorkspaceFiles(): Promise<string> {
+export async function lsFiles(dir: string): Promise<string> {
     let files: Dirent[] = []
     try {
-        const dirents = await fs.readdir(WORKSPACE_DIR(), {withFileTypes: true});
+        const dirents = await fs.readdir(dir, { withFileTypes: true });
         files = dirents.filter((dirent: Dirent) => !dirent.isDirectory());
     } catch (e) {
         if ((e as NodeJS.ErrnoException).code !== 'ENOENT') {
@@ -39,4 +36,4 @@ export async function lsWorkspaceFiles(): Promise<string> {
     }
 
     return JSON.stringify(files);
-}
+}
\ No newline at end of file
diff --git a/app/edit/page.tsx b/app/edit/page.tsx
index ccbcd0b1..1f10f626 100644
--- a/app/edit/page.tsx
+++ b/app/edit/page.tsx
@@ -5,6 +5,7 @@ import {useSearchParams} from "next/navigation";
 import Script from "@/components/script";
 import Configure from "@/components/edit/configure";
 import {EditContextProvider} from "@/contexts/edit";
+import { ScriptContextProvider } from "@/contexts/script";
 import New from "@/components/edit/new";
 import ScriptNav from "@/components/edit/scriptNav";
 
@@ -25,15 +26,17 @@ function EditFile() {
 
     return (
         <EditContextProvider file={file}>
-            <div className="w-full h-full grid grid-cols-2">
-                <div className="absolute left-6 top-6">
-                    <ScriptNav/>
+            <ScriptContextProvider initialScript={file} initialThread="">
+                <div className="w-full h-full grid grid-cols-2">
+                    <div className="absolute left-6 top-6">
+                        <ScriptNav/>
+                    </div>
+                    <div className="h-full overflow-auto w-full border-r-2 dark:border-zinc-800 p-6">
+                        <Configure file={file}/>
+                    </div>
+                    <Script messagesHeight='h-[93%]' className="p-6 overflow-auto" file={file}/>
                 </div>
-                <div className="h-full overflow-auto w-full border-r-2 dark:border-zinc-800 p-6">
-                    <Configure file={file}/>
-                </div>
-                <Script messagesHeight='h-[93%]' className="p-6 overflow-auto" file={file}/>
-            </div>
+            </ScriptContextProvider>
         </EditContextProvider>
     );
 }
diff --git a/app/run/page.tsx b/app/run/page.tsx
index f6098f69..0e65980f 100644
--- a/app/run/page.tsx
+++ b/app/run/page.tsx
@@ -5,6 +5,7 @@ import {Suspense, useState} from 'react';
 import Script from "@/components/script";
 import Threads from "@/components/threads";
 import {Thread} from '@/actions/threads';
+import {ScriptContextProvider} from "@/contexts/script";
 
 
 function RunFile() {
@@ -14,26 +15,28 @@ function RunFile() {
     const [selectedThreadId, setSelectedThreadId] = useState<string | null>(null);
 
     return (
-        <div className="w-full h-full flex pb-10">
-            <Threads
-                setThread={setThread}
-                setScript={setFile}
-                setThreads={setThreads}
-                threads={threads}
-                selectedThreadId={selectedThreadId}
-                setSelectedThreadId={setSelectedThreadId}
-            />
-            <div className="mx-auto w-1/2">
-                <Script
-                    enableThreads
-                    className="pb-10"
-                    file={file}
-                    thread={thread}
+        <ScriptContextProvider initialScript={file} initialThread={thread}>
+            <div className="w-full h-full flex pb-10">
+                <Threads
+                    setThread={setThread}
+                    setScript={setFile}
                     setThreads={setThreads}
+                    threads={threads}
+                    selectedThreadId={selectedThreadId}
                     setSelectedThreadId={setSelectedThreadId}
                 />
+                <div className="mx-auto w-1/2">
+                    <Script
+                        enableThreads
+                        className="pb-10"
+                        file={file}
+                        thread={thread}
+                        setThreads={setThreads}
+                        setSelectedThreadId={setSelectedThreadId}
+                    />
+                </div>
             </div>
-        </div>
+        </ScriptContextProvider>
     );
 }
 
diff --git a/components/edit/configure.tsx b/components/edit/configure.tsx
index 3c6c1cca..45e4edd5 100644
--- a/components/edit/configure.tsx
+++ b/components/edit/configure.tsx
@@ -13,9 +13,6 @@ import {
     Button,
     Accordion,
     AccordionItem,
-    Autocomplete,
-    AutocompleteItem,
-
 } from "@nextui-org/react";
 import {getModels} from "@/actions/models";
 import {FaPlus} from "react-icons/fa";
@@ -29,9 +26,11 @@ interface ConfigureProps {
 
 const Configure: React.FC<ConfigureProps> = ({file, className, custom}) => {
     const {
-        root, setRoot,
-        tools, setTools,
-        loading, setLoading,
+        root, 
+        setRoot,
+        tools,
+        setTools,
+        loading,
         newestToolName,
     } = useContext(EditContext);
     const [models, setModels] = useState<string[]>([]);
@@ -70,9 +69,9 @@ const Configure: React.FC<ConfigureProps> = ({file, className, custom}) => {
                     placement="bottom"
                     closeDelay={0.5}
                 >
-                    <Avatar
-                        size="md"
-                        name={abbreviate(root.name || 'Main')}
+                    <Avatar 
+                        size="md" 
+                        name={abbreviate(root.name || 'Main')} 
                         className="mx-auto mb-6 mt-4"
                         classNames={{base: "bg-white p-6 text-sm border dark:border-none dark:bg-zinc-900"}}
                     />
@@ -105,8 +104,7 @@ const Configure: React.FC<ConfigureProps> = ({file, className, custom}) => {
                     defaultValue={root.instructions}
                     onChange={(e) => setRoot({...root, instructions: e.target.value})}
                 />
-                <Models options={models} defaultValue={root.modelName}
-                        onChange={(model) => setRoot({...root, modelName: model})}/>
+                <Models options={models} defaultValue={root.modelName} onChange={(model) => setRoot({...root, modelName: model})} />
                 <Imports className="py-2" tools={root.tools} setTools={setRootTools} label={"Basic tool"}/>
                 <Imports className="py-2" tools={root.context} setTools={setRootContexts} label={"context Tool"}/>
                 <Imports className="py-2" tools={root.agents} setTools={setRootAgents} label={"agent Tool"}/>
diff --git a/components/script.tsx b/components/script.tsx
index 324e275e..797c2abe 100644
--- a/components/script.tsx
+++ b/components/script.tsx
@@ -1,17 +1,15 @@
 "use client"
 
-import React, {useState, useEffect, useRef, useCallback} from "react";
-import type {Tool} from "@gptscript-ai/gptscript";
+import React, {useEffect, useContext, useCallback, useRef} from "react";
 import Messages, {MessageType} from "@/components/script/messages";
 import ChatBar from "@/components/script/chatBar";
 import ToolForm from "@/components/script/form";
 import Loading from "@/components/loading";
-import useChatSocket from '@/components/script/useChatSocket';
 import {Button} from "@nextui-org/react";
-import {fetchScript, path} from "@/actions/scripts/fetch";
 import {getWorkspaceDir} from "@/actions/workspace";
 import {createThread, getThreads, generateThreadName, renameThread, Thread} from "@/actions/threads";
-import debounce from "lodash/debounce";
+import { ScriptContext } from "@/contexts/script";
+import {fetchScript, path} from "@/actions/scripts/fetch";
 
 interface ScriptProps {
     file: string;
@@ -23,48 +21,31 @@ interface ScriptProps {
     setSelectedThreadId?: React.Dispatch<React.SetStateAction<string | null>>
 }
 
-const Script: React.FC<ScriptProps> = ({file, thread, setThreads, className, messagesHeight = 'h-full', enableThreads, setSelectedThreadId}) => {
-    const [tool, setTool] = useState<Tool>({} as Tool);
-    const [showForm, setShowForm] = useState(true);
-    const [formValues, setFormValues] = useState<Record<string, string>>({});
-    const [inputValue, setInputValue] = useState('');
+const Script: React.FC<ScriptProps> = ({className, messagesHeight = 'h-full', enableThreads}) => {
     const inputRef = useRef<HTMLInputElement>(null);
-    const [hasRun, setHasRun] = useState(false);
-    const [hasParams, setHasParams] = useState(false);
-    const [isEmpty, setIsEmpty] = useState(false);
+    const [inputValue, setInputValue] = React.useState<string>("");
     const {
-        socket, connected, running, messages, setMessages, restart, interrupt, generating, error
-    } = useChatSocket(isEmpty);
-
-    const fetchThreads = async () => {
-        if (!setThreads) return;
-        const threads = await getThreads();
-        setThreads(threads);
-    };
-
-    useEffect(() => {
-        setHasParams(tool.arguments?.properties != undefined && Object.keys(tool.arguments?.properties).length > 0);
-        setIsEmpty(!tool.instructions);
-    }, [tool]);
-
-    useEffect(() => {
-        if (thread) restartScript();
-    }, [thread]);
-
-    useEffect(() => {
-        if (hasRun || !socket || !connected) return;
-        if (!tool.arguments?.properties || Object.keys(tool.arguments.properties).length === 0) {
-            path(file)
-                .then(async (path) => {
-                    const workspace = await getWorkspaceDir()
-                    return {path, workspace}
-                })
-                .then(({path, workspace}) => {
-                    socket.emit("run", path, tool.name, formValues, workspace, thread)
-                });
-            setHasRun(true);
-        }
-    }, [tool, connected, file, formValues, thread]);
+        script,
+        tool,
+        showForm,
+        setShowForm,
+        formValues,
+        setFormValues,
+        setHasRun,
+        hasParams,
+        messages,
+        setMessages,
+        thread,
+        setThreads,
+        setSelectedThreadId,
+        socket,
+        connected,
+        running,
+        generating,
+        restartScript,
+        interrupt,
+        fetchThreads,
+    } = useContext(ScriptContext);
 
     useEffect(() => {
         if (inputRef.current) {
@@ -72,10 +53,6 @@ const Script: React.FC<ScriptProps> = ({file, thread, setThreads, className, mes
         }
     }, [messages, inputValue]);
 
-    useEffect(() => {
-        fetchScript(file).then((data) => setTool(data));
-    }, []);
-
     useEffect(() => {
         const smallBody = document.getElementById("small-message");
         if (smallBody) smallBody.scrollTop = smallBody.scrollHeight;
@@ -84,7 +61,7 @@ const Script: React.FC<ScriptProps> = ({file, thread, setThreads, className, mes
     const handleFormSubmit = () => {
         setShowForm(false);
         setMessages([]);
-        path(file)
+        path(script)
             .then(async (path) => {
                 const workspace = await getWorkspaceDir()
                 return {path, workspace}
@@ -107,7 +84,7 @@ const Script: React.FC<ScriptProps> = ({file, thread, setThreads, className, mes
 
         let threadId = "";
         if (hasNoUserMessages() && enableThreads && !thread && setThreads && setSelectedThreadId) {
-            const newThread = await createThread(file, message)
+            const newThread = await createThread(script, message)
             threadId = newThread?.meta?.id;
             setThreads(await getThreads());
             setSelectedThreadId(threadId);
@@ -124,18 +101,6 @@ const Script: React.FC<ScriptProps> = ({file, thread, setThreads, className, mes
 
     };
 
-    const restartScript = useCallback(
-        // This is debonced as allowing the user to spam the restart button can cause race
-        // conditions. In particular, the restart may not be processed correctly and can
-        // get the user into a state where no run has been sent to the server.
-        debounce(async () => {
-            setTool(await fetchScript(file));
-            restart();
-            setHasRun(false);
-        }, 200),
-        [file, restart]
-    );
-
     const hasNoUserMessages = useCallback(() => messages.filter((m) => m.type === MessageType.User).length === 0, [messages]);
 
     return (
diff --git a/components/script/chatBar/upload.tsx b/components/script/chatBar/upload.tsx
index 6b36a314..922a56e2 100644
--- a/components/script/chatBar/upload.tsx
+++ b/components/script/chatBar/upload.tsx
@@ -1,10 +1,11 @@
-import {useState, useRef, useEffect} from 'react';
+import {useState, useRef, useEffect, useCallback, useContext} from 'react';
 import {GoFileDirectory, GoUpload, GoFile, GoX} from 'react-icons/go';
 import Files from './upload/files';
-import {uploadFile, lsWorkspaceFiles} from '@/actions/upload';
+import {uploadFile, lsFiles} from '@/actions/upload';
 import {Dirent} from 'fs';
 import Workspace from '@/components/script/chatBar/upload/workspace';
-import {
+import {ScriptContext} from '@/contexts/script';
+import { 
     Modal,
     ModalContent,
     ModalHeader,
@@ -26,17 +27,18 @@ const UploadModal = ({onRestart, disabled}: UploadModalProps) => {
     const [selectedFile, setSelectedFile] = useState<File | null>(null);
     const [files, setFiles] = useState<Dirent[]>([]);
     const selectedFileRef = useRef(selectedFile);
+    const {workspace} = useContext(ScriptContext);
 
     useEffect(() => {
         selectedFileRef.current = selectedFile
     }, [selectedFile]);
     useEffect(() => fetchFiles(), []);
 
-    const fetchFiles = () => {
-        lsWorkspaceFiles()
+    const fetchFiles = useCallback(() => {
+        lsFiles(workspace)
             .then((data: string) => setFiles(JSON.parse(data) as Dirent[]))
             .catch((error) => console.error('Error fetching files:', error));
-    }
+    }, [workspace]);
 
     const handleOpen = () => setIsOpen(true)
     const handleClose = () => setIsOpen(false);
@@ -47,7 +49,7 @@ const UploadModal = ({onRestart, disabled}: UploadModalProps) => {
         if (selectedFileRef.current) {
             const formData = new FormData();
             formData.append('file', selectedFileRef.current);
-            uploadFile(formData);
+            uploadFile(workspace, formData);
         }
         fetchFiles();
         handleCancel();
diff --git a/components/script/chatBar/upload/files.tsx b/components/script/chatBar/upload/files.tsx
index ae9e6c4c..e716c07b 100644
--- a/components/script/chatBar/upload/files.tsx
+++ b/components/script/chatBar/upload/files.tsx
@@ -1,8 +1,9 @@
-import {useEffect} from 'react';
+import {useEffect, useContext, useCallback} from 'react';
 import {GoTrash, GoFile} from 'react-icons/go';
-import {Table, TableBody, TableHeader, TableRow, TableCell, TableColumn, Button} from '@nextui-org/react'; // Replace 'next-ui' with the actual package name
-import {deleteFile, lsWorkspaceFiles} from '@/actions/upload';
+import {Table, TableBody, TableHeader, TableRow, TableCell, TableColumn, Button} from '@nextui-org/react';
+import {deleteFile, lsFiles} from '@/actions/upload';
 import {Dirent} from 'fs';
+import {ScriptContext} from '@/contexts/script';
 import path from 'path';
 
 interface FilesProps {
@@ -12,12 +13,13 @@ interface FilesProps {
 
 const Files: React.FC<FilesProps> = ({files, setFiles}) => {
     useEffect(() => fetchFiles(), []);
+    const {workspace} = useContext(ScriptContext);
 
-    const fetchFiles = () => {
-        lsWorkspaceFiles()
+    const fetchFiles = useCallback(() => {
+        lsFiles(workspace)
             .then((data: string) => setFiles(JSON.parse(data) as Dirent[]))
             .catch((error) => console.error('Error fetching files:', error));
-    }
+    }, [workspace]);
 
     return (
         <Table removeWrapper aria-label="files">
diff --git a/components/script/chatBar/upload/workspace.tsx b/components/script/chatBar/upload/workspace.tsx
index 6f0779f5..9a0221f9 100644
--- a/components/script/chatBar/upload/workspace.tsx
+++ b/components/script/chatBar/upload/workspace.tsx
@@ -1,6 +1,6 @@
-import {useState, useCallback, useRef, useEffect} from 'react';
-import {getWorkspaceDir, setWorkspaceDir} from '@/actions/workspace';
-import {
+import {useState, useCallback, useContext, useEffect} from 'react';
+import {ScriptContext} from '@/contexts/script';
+import { 
     Modal,
     ModalContent,
     ModalHeader,
@@ -9,6 +9,7 @@ import {
     Button,
     Input,
 } from '@nextui-org/react';
+import { updateThreadWorkspace } from '@/actions/threads';
 
 interface WorkspaceProps {
     onRestart: () => void;
@@ -16,40 +17,38 @@ interface WorkspaceProps {
 
 const Workspace = ({onRestart}: WorkspaceProps) => {
     const [isOpen, setIsOpen] = useState(false);
-    const [workspace, setWorkspace] = useState<string>('');
-    const [actingWorkspace, setActingWorkspace] = useState<string>('');
+    const {workspace, setWorkspace, thread} = useContext(ScriptContext);
+    const [workspaceInput, setWorkspaceInput] = useState<string>('');
 
     useEffect(() => {
-        getWorkspaceDir().then((wd) => setActingWorkspace(wd))
-    }, []);
-
-    useEffect(() => {
-        setWorkspace(actingWorkspace)
-    }, [actingWorkspace]);
+        setWorkspaceInput(workspace)
+    }, [workspace]);
 
     const handleOpen = () => setIsOpen(true)
     const handleClose = () => setIsOpen(false);
     const handleConfirm = useCallback(() => {
-        setWorkspaceDir(workspace);
+        setWorkspace(workspaceInput);
         setIsOpen(false);
+        updateThreadWorkspace(thread, workspaceInput);
         onRestart();
-    }, [workspace]);
+    }, [workspaceInput]);
 
     return (
         <div className="flex w-full space-x-4">
             <Input
+                spellCheck={false}
                 color="primary"
                 variant="bordered"
                 placeholder="Set your workspace folder..."
                 label="Workspace folder"
-                value={workspace}
-                onKeyDown={(event) => event.key === 'Enter' && actingWorkspace != workspace && handleConfirm()}
-                onChange={(event) => setWorkspace(event.target.value)}
+                value={workspaceInput}
+                onKeyDown={(event) => event.key === 'Enter' && workspaceInput != workspace && handleConfirm()}
+                onChange={(event) => setWorkspaceInput(event.target.value) }
             />
-            {workspace != actingWorkspace &&
-                <Button
-                    className="absolute right-8 mt-2"
-                    color="danger"
+            { workspace != workspaceInput &&
+                <Button 
+                    className="absolute right-8 mt-2" 
+                    color="danger" 
                     onPress={handleOpen}
                 >
                     Update
diff --git a/components/threads.tsx b/components/threads.tsx
index ca21f529..d6fd46ac 100644
--- a/components/threads.tsx
+++ b/components/threads.tsx
@@ -1,9 +1,10 @@
-import React, {useState, useEffect} from 'react';
+import React, {useState, useEffect, useContext} from 'react';
 import New from './threads/new';
 import Menu from './threads/menu';
 import {getThreads, Thread} from '@/actions/threads';
 import {Button, Divider, Tooltip} from '@nextui-org/react';
 import {GoSidebarExpand, GoSidebarCollapse} from 'react-icons/go';
+import {ScriptContext} from '@/contexts/script';
 
 interface ThreadsProps {
     className?: string;
@@ -15,18 +16,16 @@ interface ThreadsProps {
     setScript: React.Dispatch<React.SetStateAction<string>>;
 }
 
-const Threads: React.FC<ThreadsProps> = ({className, setThread, threads, setThreads, setScript, selectedThreadId, setSelectedThreadId}) => {
+const Threads: React.FC<ThreadsProps> = ({className}) => {
+    const {
+        setScript,
+        setThread, 
+        threads,
+        selectedThreadId,
+        setSelectedThreadId,
+    } = useContext(ScriptContext);
     const [isCollapsed, setIsCollapsed] = useState(false);
 
-    useEffect(() => {
-        fetchThreads()
-    }, []);
-
-    const fetchThreads = async () => {
-        const threads = await getThreads();
-        setThreads(threads);
-    };
-
     const handleRun = async (script: string, id: string) => {
         setScript(script);
         setThread(id);
@@ -49,8 +48,7 @@ const Threads: React.FC<ThreadsProps> = ({className, setThread, threads, setThre
                         isIconOnly
                     />
                 </Tooltip>
-                <New setSelectedThreadId={setSelectedThreadId} setThread={setThread} setThreads={setThreads}
-                     setScript={setScript}/>
+                <New />
             </div>
             <div style={{width: isCollapsed ? '50px' : '250px', transition: 'width 0.3s ease-in-out'}}>
                 <Divider className="mb-4" style={{opacity: isCollapsed ? 0 : 1, transition: 'opacity 0.2s 0.2s'}}/>
@@ -70,8 +68,7 @@ const Threads: React.FC<ThreadsProps> = ({className, setThread, threads, setThre
                                     >
                                         <div className="flex justify-between items-center">
                                             <h2 className="text-sm truncate">{thread.meta.name}</h2>
-                                            <Menu className={isSelected(thread.meta.id) ? 'text-white' : ''}
-                                                  setThreads={setThreads} threadId={thread.meta.id}/>
+                                            <Menu threadId={thread.meta.id}/>
                                         </div>
                                     </div>
                                 </Tooltip>
diff --git a/components/threads/menu.tsx b/components/threads/menu.tsx
index 703476eb..47bdbe30 100644
--- a/components/threads/menu.tsx
+++ b/components/threads/menu.tsx
@@ -1,32 +1,35 @@
-import {useState} from "react";
+import {useState, useContext} from "react";
 import {Popover, PopoverTrigger, PopoverContent, Button, Menu, MenuItem} from "@nextui-org/react";
 import {deleteThread, renameThread, Thread} from '@/actions/threads';
 import {GoPencil, GoTrash, GoKebabHorizontal} from "react-icons/go";
+import {ScriptContext} from '@/contexts/script';
 
 interface NewThreadProps {
     className?: string;
     threadId: string;
-    setThreads: React.Dispatch<React.SetStateAction<Thread[]>>;
 }
 
-const NewThread = ({className, threadId, setThreads}: NewThreadProps) => {
+const NewThread = ({className, }: NewThreadProps) => {
     const [isOpen, setIsOpen] = useState(false);
+    const {
+        thread, setThreads,
+    } = useContext(ScriptContext);
 
     const handleDeleteThread = () => {
-        deleteThread(threadId).then(() => {
-            setThreads((threads: Thread[]) => threads.filter((thread: Thread) => thread.meta.id !== threadId));
+        deleteThread(thread).then(() => {
+            setThreads((threads: Thread[]) => threads.filter((t: Thread) => t.meta.id !== thread));
         });
     };
 
     const handleRenameThread = () => {
         const newName = prompt("Enter a new name for the thread");
         if (newName) {
-            renameThread(threadId, newName).then(() => {
-                setThreads((threads: Thread[]) => threads.map((thread: Thread) => {
-                    if (thread.meta.id === threadId) {
-                        return {...thread, meta: {...thread.meta, name: newName}};
+            renameThread(thread, newName).then(() => {
+                setThreads((threads: Thread[]) => threads.map((t: Thread) => {
+                    if (t.meta.id === thread) {
+                        return { ...t, meta: { ...t.meta, name: newName } };
                     }
-                    return thread;
+                    return t;
                 }));
             });
         }
diff --git a/components/threads/new.tsx b/components/threads/new.tsx
index 6682485d..92ad3e1c 100644
--- a/components/threads/new.tsx
+++ b/components/threads/new.tsx
@@ -1,20 +1,23 @@
-import {Popover, PopoverTrigger, PopoverContent, Button, Menu, MenuItem, MenuSection, Input} from "@nextui-org/react";
+import {Popover, PopoverTrigger, PopoverContent, Button, Menu, MenuItem, MenuSection} from "@nextui-org/react";
 import {createThread, Thread} from '@/actions/threads';
 import {fetchScripts} from '@/actions/scripts/fetch';
-import {useEffect, useState} from 'react';
-import {GoPencil, GoPersonFill, GoPlus} from "react-icons/go";
+import {useEffect, useState, useContext} from 'react';
+import {GoPlus} from "react-icons/go";
+import {ScriptContext} from '@/contexts/script';
 
 interface NewThreadProps {
     className?: string;
-    setSelectedThreadId: React.Dispatch<React.SetStateAction<string | null>>;
-    setThread: React.Dispatch<React.SetStateAction<string>>;
-    setScript: React.Dispatch<React.SetStateAction<string>>;
-    setThreads: React.Dispatch<React.SetStateAction<Thread[]>>;
 }
 
-const NewThread = ({className, setThread, setSelectedThreadId, setScript, setThreads}: NewThreadProps) => {
+const NewThread = ({className}: NewThreadProps) => {
     const [scripts, setScripts] = useState<Record<string, string>>({});
     const [isOpen, setIsOpen] = useState(false);
+    const {
+        setThread, 
+        setSelectedThreadId, 
+        setScript, 
+        setThreads,
+    } = useContext(ScriptContext);
 
     useEffect(() => {
         fetchScripts().then((data) => {
diff --git a/contexts/script.tsx b/contexts/script.tsx
new file mode 100644
index 00000000..15d4d647
--- /dev/null
+++ b/contexts/script.tsx
@@ -0,0 +1,176 @@
+import { createContext, useState, useRef, useEffect, useCallback } from 'react';
+import useChatSocket from '@/components/script/useChatSocket'
+import { Message } from '@/components/script/messages';
+import { Tool } from '@gptscript-ai/gptscript';
+import { Socket } from 'socket.io-client';
+import { Thread } from '@/actions/threads';
+import {fetchScript, path} from "@/actions/scripts/fetch";
+import { getThreads, getThread } from '@/actions/threads';
+import debounce from 'lodash/debounce';
+import { getWorkspaceDir } from '@/actions/workspace';
+
+interface ScriptContextProps{
+    children: React.ReactNode
+    initialScript: string
+    initialThread: string
+}
+
+interface ScriptContextState {
+    script: string;
+    workspace: string;
+    setWorkspace: React.Dispatch<React.SetStateAction<string>>;
+    setScript: React.Dispatch<React.SetStateAction<string>>;
+    tool: Tool;
+    setTool: React.Dispatch<React.SetStateAction<Tool>>;
+    showForm: boolean;
+    setShowForm: React.Dispatch<React.SetStateAction<boolean>>;
+    formValues: Record<string, string>;
+    setFormValues: React.Dispatch<React.SetStateAction<Record<string, string>>>;
+    inputRef: React.RefObject<HTMLInputElement>;
+    hasRun: boolean;
+    setHasRun: React.Dispatch<React.SetStateAction<boolean>>;
+    hasParams: boolean;
+    setHasParams: React.Dispatch<React.SetStateAction<boolean>>;
+    isEmpty: boolean;
+    setIsEmpty: React.Dispatch<React.SetStateAction<boolean>>;
+    notFound: boolean;
+    setNotFound: React.Dispatch<React.SetStateAction<boolean>>;
+    messages: Message[];
+    setMessages: React.Dispatch<React.SetStateAction<Message[]>>;
+    thread: string;
+    setThread:React.Dispatch<React.SetStateAction<string>>;
+    threads: Thread[];
+    setThreads: React.Dispatch<React.SetStateAction<Thread[]>>;
+    selectedThreadId: string | null;
+    setSelectedThreadId: React.Dispatch<React.SetStateAction<string | null>>;
+    socket: Socket | null;
+    connected: boolean;
+    running: boolean;
+    generating: boolean;
+    error: string | null;
+
+    restart: () => void;
+    interrupt: () => void;
+    fetchThreads: () => void;
+    restartScript: () => void;
+}
+
+const ScriptContext = createContext<ScriptContextState>({} as ScriptContextState);
+const ScriptContextProvider: React.FC<ScriptContextProps> = ({children, initialScript, initialThread}) => {
+    const [script, setScript] = useState<string>(initialScript);
+    const [workspace, setWorkspace] = useState('');
+    const [tool, setTool] = useState<Tool>({} as Tool);
+	const [showForm, setShowForm] = useState(true);
+	const [formValues, setFormValues] = useState<Record<string, string>>({});
+	const inputRef = useRef<HTMLInputElement>(null);
+	const [hasRun, setHasRun] = useState(false);
+	const [hasParams, setHasParams] = useState(false);
+    const [isEmpty, setIsEmpty] = useState(false);
+    const [notFound, setNotFound] = useState(false);
+    const [thread, setThread] = useState<string>(initialThread);
+    const [threads, setThreads] = useState<Thread[]>([]);
+    const [selectedThreadId, setSelectedThreadId] = useState<string | null>(null);
+    const [initialFetch, setInitialFetch] = useState(false);
+    const { 
+        socket, connected, running, messages, setMessages, restart, interrupt, generating, error
+    } = useChatSocket(isEmpty);
+
+    // need to initialize the workspace from the env variable with serves
+    // as the default.
+    useEffect(() => {
+        fetchThreads();
+        getWorkspaceDir().then((workspace) => {
+            setWorkspace(workspace);
+        });
+    }, [])
+
+    useEffect(() => {
+        fetchScript(script)
+            .then((data) => {
+                setTool(data);
+                setInitialFetch(true);
+            });
+    }, [script]);
+
+    useEffect(() => {
+        setHasParams(tool.arguments?.properties != undefined && Object.keys(tool.arguments?.properties).length > 0);
+        setIsEmpty(!tool.instructions);
+    }, [tool]);
+
+    useEffect(() => {
+        if(thread) {
+            getThread(thread)
+                .then((thread) => {
+                    if(thread) setWorkspace(thread.meta.workspace);
+                });
+            restartScript();
+        }
+    }, [thread]);
+
+    useEffect(() => {
+        if (hasRun || !socket || !connected) return;
+        if (!tool.arguments?.properties || Object.keys(tool.arguments.properties).length === 0) {
+            path(script)
+                .then((path) => {
+                    socket.emit("run", path, tool.name, formValues, workspace, thread)
+                });
+            setHasRun(true);
+        }
+    }, [tool, connected, script, formValues, thread, workspace]);
+
+	useEffect(() => {
+		const smallBody = document.getElementById("small-message");
+		if (smallBody) smallBody.scrollTop = smallBody.scrollHeight;
+	}, [messages, connected, running]);
+
+    const fetchThreads = async () => {
+        if (!setThreads) return;
+        const threads = await getThreads();
+        setThreads(threads);
+    };
+
+    const restartScript = useCallback(
+        // This is debonced as allowing the user to spam the restart button can cause race
+        // conditions. In particular, the restart may not be processed correctly and can
+        // get the user into a state where no run has been sent to the server.
+        debounce(async () => {
+            setTool(await fetchScript(script));
+            restart();
+            setHasRun(false);
+        }, 200),
+    [script, restart]);
+
+    return (
+        <ScriptContext.Provider 
+            value={{
+                script, setScript,
+                workspace, setWorkspace,
+                tool, setTool,
+                showForm, setShowForm,
+                formValues, setFormValues,
+                inputRef,
+                hasRun, setHasRun,
+                hasParams, setHasParams,
+                isEmpty, setIsEmpty,
+                notFound, setNotFound,
+                messages, setMessages,
+                thread, setThread,
+                threads, setThreads,
+                selectedThreadId, setSelectedThreadId,
+                socket,
+                connected,
+                running,
+                generating,
+                error,
+                restart,
+                interrupt,
+                fetchThreads,
+                restartScript,
+            }}
+        >
+            {children}
+        </ScriptContext.Provider>
+    );
+};
+
+export { ScriptContext, ScriptContextProvider };
\ No newline at end of file
diff --git a/server/app.mjs b/server/app.mjs
index 954edaba..8d40275a 100644
--- a/server/app.mjs
+++ b/server/app.mjs
@@ -42,14 +42,14 @@ export const startAppServer = ({dev, hostname, port, dir}) => {
 
             io.on("connection", (socket) => {
                 io.emit("message", "connected");
-                socket.on("run", async (file, tool, args, workspace, threadID) => {
+                socket.on("run", async (file, tool, args, scriptWorkspace, threadID) => {
                     if (runningScript) {
                         await runningScript.close();
                         runningScript = null;
                     }
                     try {
                         dismount(socket);
-                        await mount(file, tool, args, workspace, socket, threadID, gptscript);
+                        await mount(file, tool, args, scriptWorkspace, socket, threadID, gptscript);
                     } catch (e) {
                         socket.emit("error", e);
                     }
@@ -71,21 +71,22 @@ export const startAppServer = ({dev, hostname, port, dir}) => {
     });
 };
 
-const mount = async (file, tool, args, workspace, socket, threadID, gptscript) => {
+const mount = async (file, tool, args, scriptWorkspace, socket, threadID, gptscript) => {
+    const WORKSPACE_DIR = process.env.WORKSPACE_DIR ?? process.env.GPTSCRIPT_WORKSPACE_DIR;
+    const THREADS_DIR = process.env.THREADS_DIR ?? path.join(WORKSPACE_DIR, "threads");
+
     const opts = {
         input: JSON.stringify(args || {}),
         disableCache: DISABLE_CACHE,
-        workspace: workspace,
+        workspace: scriptWorkspace,
         prompt: true,
         confirm: true,
     };
-
+    
     if (tool) opts.subTool = tool;
-
+    
     let state = {};
     let statePath = '';
-    let THREADS_DIR = process.env.THREADS_DIR
-    if (!THREADS_DIR) THREADS_DIR = path.join(workspace, "threads");
     if (threadID) statePath = path.join(THREADS_DIR, threadID, STATE_FILE);
     try {
         state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
@@ -180,7 +181,8 @@ const mount = async (file, tool, args, workspace, socket, threadID, gptscript) =
         runningScript.text()
             .then((output) => {
                 if (!runningScript) return;
-                if (!state.messages) state.messages.push(
+                if (!state.messages) state.messages = [];
+                state.messages.push(
                     {type: USER, message: message},
                     {type: AGENT, message: output}
                 );